home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / net / RCS / ruserpass.c,v < prev    next >
Text File  |  1989-05-18  |  20KB  |  1,158 lines
  1. head     1.8;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.8
  10. date     89.05.18.17.15.08;  author rab;  state Exp;
  11. branches ;
  12. next     1.7;
  13.  
  14. 1.7
  15. date     88.07.29.17.53.03;  author ouster;  state Exp;
  16. branches ;
  17. next     1.6;
  18.  
  19. 1.6
  20. date     88.07.29.17.00.08;  author ouster;  state Exp;
  21. branches ;
  22. next     1.5;
  23.  
  24. 1.5
  25. date     88.07.25.13.46.08;  author ouster;  state Exp;
  26. branches ;
  27. next     1.4;
  28.  
  29. 1.4
  30. date     88.07.25.13.10.09;  author ouster;  state Exp;
  31. branches ;
  32. next     1.3;
  33.  
  34. 1.3
  35. date     88.07.25.11.01.10;  author ouster;  state Exp;
  36. branches ;
  37. next     1.2;
  38.  
  39. 1.2
  40. date     88.07.20.14.38.21;  author ouster;  state Exp;
  41. branches ;
  42. next     1.1;
  43.  
  44. 1.1
  45. date     88.06.20.09.57.23;  author ouster;  state Exp;
  46. branches ;
  47. next     ;
  48.  
  49.  
  50. desc
  51. @@
  52.  
  53.  
  54. 1.8
  55. log
  56. @Added forward declarations for static functions.
  57. @
  58. text
  59. @/*
  60.  * Copyright (c) 1983 Regents of the University of California.
  61.  * All rights reserved.
  62.  *
  63.  * Redistribution and use in source and binary forms are permitted
  64.  * provided that this notice is preserved and that due credit is given
  65.  * to the University of California at Berkeley. The name of the University
  66.  * may not be used to endorse or promote products derived from this
  67.  * software without specific prior written permission. This software
  68.  * is provided ``as is'' without express or implied warranty.
  69.  */
  70.  
  71. #if defined(LIBC_SCCS) && !defined(lint)
  72. static char sccsid[] = "@@(#)ruserpass.c    5.4 (Berkeley) 3/7/88";
  73. #endif /* LIBC_SCCS and not lint */
  74.  
  75. #include <stdio.h>
  76. #include <utmp.h>
  77. #include <ctype.h>
  78. #include <sys/types.h>
  79. #include <sys/stat.h>
  80. #include <errno.h>
  81. #include <strings.h>
  82.  
  83. #if !defined(__STDC__) && !defined(const)
  84. #define const /**/
  85. #endif
  86.  
  87. extern char *malloc(), *index(), *getenv(), *getpass(), *getlogin();
  88. extern char *ttyname();
  89. extern void mkpwclear();
  90. static void renv();
  91. static void rnetrc();
  92. static int token();
  93. static void enblkclr();
  94. static void enblknot();
  95. static void nbssetkey();
  96. static void blkencrypt();
  97. static struct utmp *getutmp();
  98. static char *renvlook();
  99. static char *deblknot(), *deblkclr();
  100. static char *nbs8decrypt(), *nbs8encrypt();
  101.  
  102. static    FILE *cfile;
  103. static char E[48];
  104.  
  105. void
  106. ruserpass(host, aname, apass)
  107.     char *host, **aname, **apass;
  108. {
  109.  
  110.     renv(host, aname, apass);
  111.     if (*aname == 0 || *apass == 0)
  112.         rnetrc(host, aname, apass);
  113.     if (*aname == 0) {
  114.         char *myname = getlogin();
  115.         *aname = malloc(16);
  116.         printf("Name (%s:%s): ", host, myname);
  117.         fflush(stdout);
  118.         if (read(2, *aname, 16) <= 0)
  119.             exit(1);
  120.         if ((*aname)[0] == '\n')
  121.             *aname = myname;
  122.         else
  123.             if (index(*aname, '\n'))
  124.                 *index(*aname, '\n') = 0;
  125.     }
  126.     if (*aname && *apass == 0) {
  127.         printf("Password (%s:%s): ", host, *aname);
  128.         fflush(stdout);
  129.         *apass = getpass("");
  130.     }
  131.     return;
  132. }
  133.  
  134. static void
  135. renv(host, aname, apass)
  136.     char *host, **aname, **apass;
  137. {
  138.     register char *cp;
  139.     char *comma;
  140.  
  141.     cp = renvlook(host);
  142.     if (cp == NULL)
  143.         return;
  144.     if (!isalpha(cp[0]))
  145.         return;
  146.     comma = index(cp, ',');
  147.     if (comma == 0)
  148.         return;
  149.     if (*aname == 0) {
  150.         *aname = malloc((unsigned) (comma - cp + 1));
  151.         strncpy(*aname, cp, comma - cp);
  152.     } else
  153.         if (strncmp(*aname, cp, comma - cp))
  154.             return;
  155.     comma++;
  156.     cp = malloc((unsigned) (strlen(comma)+1));
  157.     strcpy(cp, comma);
  158.     *apass = malloc(16);
  159.     mkpwclear(cp, host[0], *apass);
  160.     return;
  161. }
  162.  
  163. static char *
  164. renvlook(host)
  165.     char *host;
  166. {
  167.     register char *cp, **env;
  168.     extern char **environ;
  169.  
  170.     env = environ;
  171.     for (env = environ; *env != NULL; env++)
  172.         if (!strncmp(*env, "MACH", 4)) {
  173.             cp = index(*env, '=');
  174.             if (cp == 0)
  175.                 continue;
  176.             if (strncmp(*env+4, host, cp-(*env+4)))
  177.                 continue;
  178.             return (cp+1);
  179.         }
  180.     return (NULL);
  181. }
  182.  
  183. #define    DEFAULT    1
  184. #define    LOGIN    2
  185. #define    PASSWD    3
  186. #define    NOTIFY    4
  187. #define    WRITE    5
  188. #define    YES    6
  189. #define    NO    7
  190. #define    COMMAND    8
  191. #define    FORCE    9
  192. #define    ID    10
  193. #define    MACHINE    11
  194.  
  195. static char tokval[100];
  196.  
  197. static struct toktab {
  198.     char *tokstr;
  199.     int tval;
  200. } toktab[]= {
  201.     "default",    DEFAULT,
  202.     "login",    LOGIN,
  203.     "password",    PASSWD,
  204.     "notify",    NOTIFY,
  205.     "write",    WRITE,
  206.     "yes",        YES,
  207.     "y",        YES,
  208.     "no",        NO,
  209.     "n",        NO,
  210.     "command",    COMMAND,
  211.     "force",    FORCE,
  212.     "machine",    MACHINE,
  213.     0,        0
  214. };
  215.  
  216. static void
  217. rnetrc(host, aname, apass)
  218.     char *host, **aname, **apass;
  219. {
  220.     char *hdir, buf[BUFSIZ];
  221.     int t;
  222.     struct stat stb;
  223.     extern int errno;
  224.  
  225.     hdir = getenv("HOME");
  226.     if (hdir == NULL)
  227.         hdir = ".";
  228.     (void)sprintf(buf, "%s/.netrc", hdir);
  229.     cfile = fopen(buf, "r");
  230.     if (cfile == NULL) {
  231.         if (errno != ENOENT)
  232.             perror(buf);
  233.         return;
  234.     }
  235. next:
  236.     while ((t = token())) switch(t) {
  237.  
  238.     case DEFAULT:
  239.         (void) token();
  240.         continue;
  241.  
  242.     case MACHINE:
  243.         if (token() != ID || strcmp(host, tokval))
  244.             continue;
  245.         while ((t = token()) && t != MACHINE) switch(t) {
  246.  
  247.         case LOGIN:
  248.             if (token())
  249.                 if (*aname == 0) { 
  250.                     *aname = malloc((unsigned)
  251.                         (strlen(tokval) + 1));
  252.                     strcpy(*aname, tokval);
  253.                 } else {
  254.                     if (strcmp(*aname, tokval))
  255.                         goto next;
  256.                 }
  257.             break;
  258.         case PASSWD:
  259.             if (fstat(fileno(cfile), &stb) >= 0
  260.                 && (stb.st_mode & 077) != 0) {
  261.     fprintf(stderr, "Error - .netrc file not correct mode.\n");
  262.     fprintf(stderr, "Remove password or correct mode.\n");
  263.                 exit(1);
  264.             }
  265.             if (token() && *apass == 0) {
  266.                 *apass = malloc((unsigned)
  267.                     (strlen(tokval) + 1));
  268.                 strcpy(*apass, tokval);
  269.             }
  270.             break;
  271.         case COMMAND:
  272.         case NOTIFY:
  273.         case WRITE:
  274.         case FORCE:
  275.             (void) token();
  276.             break;
  277.         default:
  278.     fprintf(stderr, "Unknown .netrc option %s\n", tokval);
  279.             break;
  280.         }
  281.         goto done;
  282.     }
  283. done:
  284.     fclose(cfile);
  285. }
  286.  
  287. static int
  288. token()
  289. {
  290.     char *cp;
  291.     int c;
  292.     struct toktab *t;
  293.  
  294.     if (feof(cfile))
  295.         return (0);
  296.     while ((c = getc(cfile)) != EOF &&
  297.         (c == '\n' || c == '\t' || c == ' ' || c == ','))
  298.         continue;
  299.     if (c == EOF)
  300.         return (0);
  301.     cp = tokval;
  302.     if (c == '"') {
  303.         while ((c = getc(cfile)) != EOF && c != '"') {
  304.             if (c == '\\')
  305.                 c = getc(cfile);
  306.             *cp++ = c;
  307.         }
  308.     } else {
  309.         *cp++ = c;
  310.         while ((c = getc(cfile)) != EOF
  311.             && c != '\n' && c != '\t' && c != ' ' && c != ',') {
  312.             if (c == '\\')
  313.                 c = getc(cfile);
  314.             *cp++ = c;
  315.         }
  316.     }
  317.     *cp = 0;
  318.     if (tokval[0] == 0)
  319.         return (0);
  320.     for (t = toktab; t->tokstr; t++)
  321.         if (!strcmp(t->tokstr, tokval))
  322.             return (t->tval);
  323.     return (ID);
  324. }
  325. /* rest is nbs.c stolen from berknet */
  326.  
  327. /*
  328.  * The E bit-selection table.
  329.  */
  330. static char    e[] = {
  331.     32, 1, 2, 3, 4, 5,
  332.      4, 5, 6, 7, 8, 9,
  333.      8, 9,10,11,12,13,
  334.     12,13,14,15,16,17,
  335.     16,17,18,19,20,21,
  336.     20,21,22,23,24,25,
  337.     24,25,26,27,28,29,
  338.     28,29,30,31,32, 1,
  339. };
  340.  
  341. static char *
  342. nbsencrypt(str,key,result)
  343.   char *result;
  344.   char *str, *key;
  345. {
  346.     static char buf[20],oldbuf[20];
  347.     register int j;
  348.     result[0] = 0;
  349.     strcpy(oldbuf,key);
  350.     while(*str){
  351.         for(j=0;j<10;j++)buf[j] = 0;
  352.         for(j=0;j<8 && *str;j++)buf[j] = *str++;
  353.         strcat(result,nbs8encrypt(buf,oldbuf));
  354.         strcat(result,"$");
  355.         strcpy(oldbuf,buf);
  356.         }
  357.     return(result);
  358. }
  359.  
  360. static char *
  361. nbsdecrypt(cpt,key,result)
  362.   char *result;
  363.   char *cpt,*key;
  364. {
  365.     char *s;
  366.     char c,oldbuf[20];
  367.     result[0] = 0;
  368.     strcpy(oldbuf,key);
  369.     while(*cpt){
  370.         for(s = cpt;*s && *s != '$';s++);
  371.         c = *s;
  372.         *s = 0;
  373.         strcpy(oldbuf,nbs8decrypt(cpt,oldbuf));
  374.         strcat(result,oldbuf);
  375.         if(c == 0)break;
  376.         cpt = s + 1;
  377.         }
  378.     return(result);
  379.     }
  380.  
  381. static char *
  382. nbs8encrypt(str,key)
  383.     char *str, *key;
  384. {
  385.     static char keyblk[100], blk[100];
  386.     register int i;
  387.  
  388.     enblkclr(keyblk,key);
  389.     nbssetkey(keyblk);
  390.  
  391.     for(i=0;i<48;i++) E[i] = e[i];
  392.     enblkclr(blk,str);
  393.     blkencrypt(blk,0);            /* forward dir */
  394.  
  395.     return(deblknot(blk));
  396. }
  397.  
  398. static char *
  399. nbs8decrypt(crp,key)
  400.     char *crp, *key;
  401. {
  402.     static char keyblk[100], blk[100];
  403.     register int i;
  404.  
  405.     enblkclr(keyblk,key);
  406.     nbssetkey(keyblk);
  407.  
  408.     for(i=0;i<48;i++) E[i] = e[i];
  409.     enblknot(blk,crp);
  410.     blkencrypt(blk,1);            /* backward dir */
  411.  
  412.     return(deblkclr(blk));
  413. }
  414.  
  415. static void
  416. enblkclr(blk,str)        /* ignores top bit of chars in string str */
  417. char *blk,*str;
  418. {
  419.     register int i,j;
  420.     char c;
  421.     for(i=0;i<70;i++)blk[i] = 0;
  422.     for(i=0; (c= *str) && i<64; str++){
  423.         for(j=0; j<7; j++, i++)
  424.         blk[i] = (c>>(6-j)) & 01;
  425.         i++;
  426.     }
  427.     return;
  428. }
  429.  
  430. static
  431. char *deblkclr(blk)
  432. char *blk; {
  433.     register int i,j;
  434.     char c;
  435.     static char iobuf[30];
  436.     for(i=0; i<10; i++){
  437.         c = 0;
  438.         for(j=0; j<7; j++){
  439.             c <<= 1;
  440.             c |= blk[8*i+j];
  441.             }
  442.         iobuf[i] = c;
  443.     }
  444.     iobuf[i] = 0;
  445.     return(iobuf);
  446.     }
  447.  
  448. static void
  449. enblknot(blk,crp)
  450.     char *blk;
  451.     char *crp;
  452. {
  453.     register int i,j;
  454.     char c;
  455.  
  456.     for(i=0;i<70;i++)blk[i] = 0;
  457.     for(i=0; (c= *crp) && i<64; crp++){
  458.         if(c>'Z') c -= 6;
  459.         if(c>'9') c -= 7;
  460.         c -= '.';
  461.         for(j=0; j<6; j++, i++)
  462.         blk[i] = (c>>(5-j)) & 01;
  463.     }
  464. }
  465.  
  466. static char *
  467. deblknot(blk)
  468.     char *blk;
  469. {
  470.     register int i,j;
  471.     char c;
  472.     static char iobuf[30];
  473.  
  474.     for(i=0; i<11; i++) {
  475.         c = 0;
  476.         for(j=0; j<6; j++){
  477.             c <<= 1;
  478.             c |= blk[6*i+j];
  479.             }
  480.         c += '.';
  481.         if(c > '9')c += 7;
  482.         if(c > 'Z')c += 6;
  483.         iobuf[i] = c;
  484.     }
  485.     iobuf[i] = 0;
  486.     return(iobuf);
  487. }
  488.  
  489. /*
  490.  * This program implements the
  491.  * Proposed Federal Information Processing
  492.  *  Data Encryption Standard.
  493.  * See Federal Register, March 17, 1975 (40FR12134)
  494.  */
  495.  
  496. /*
  497.  * Initial permutation,
  498.  */
  499. static    char    IP[] = {
  500.     58,50,42,34,26,18,10, 2,
  501.     60,52,44,36,28,20,12, 4,
  502.     62,54,46,38,30,22,14, 6,
  503.     64,56,48,40,32,24,16, 8,
  504.     57,49,41,33,25,17, 9, 1,
  505.     59,51,43,35,27,19,11, 3,
  506.     61,53,45,37,29,21,13, 5,
  507.     63,55,47,39,31,23,15, 7,
  508. };
  509.  
  510. /*
  511.  * Final permutation, FP = IP^(-1)
  512.  */
  513. static const char FP[] = {
  514.     40, 8,48,16,56,24,64,32,
  515.     39, 7,47,15,55,23,63,31,
  516.     38, 6,46,14,54,22,62,30,
  517.     37, 5,45,13,53,21,61,29,
  518.     36, 4,44,12,52,20,60,28,
  519.     35, 3,43,11,51,19,59,27,
  520.     34, 2,42,10,50,18,58,26,
  521.     33, 1,41, 9,49,17,57,25,
  522. };
  523.  
  524. /*
  525.  * Permuted-choice 1 from the key bits
  526.  * to yield C and D.
  527.  * Note that bits 8,16... are left out:
  528.  * They are intended for a parity check.
  529.  */
  530. static const char PC1_C[] = {
  531.     57,49,41,33,25,17, 9,
  532.      1,58,50,42,34,26,18,
  533.     10, 2,59,51,43,35,27,
  534.     19,11, 3,60,52,44,36,
  535. };
  536.  
  537. static const char PC1_D[] = {
  538.     63,55,47,39,31,23,15,
  539.      7,62,54,46,38,30,22,
  540.     14, 6,61,53,45,37,29,
  541.     21,13, 5,28,20,12, 4,
  542. };
  543.  
  544. /*
  545.  * Sequence of shifts used for the key schedule.
  546. */
  547. static const char shifts[] = {
  548.     1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
  549. };
  550.  
  551. /*
  552.  * Permuted-choice 2, to pick out the bits from
  553.  * the CD array that generate the key schedule.
  554.  */
  555. static const char PC2_C[] = {
  556.     14,17,11,24, 1, 5,
  557.      3,28,15, 6,21,10,
  558.     23,19,12, 4,26, 8,
  559.     16, 7,27,20,13, 2,
  560. };
  561.  
  562. static const char PC2_D[] = {
  563.     41,52,31,37,47,55,
  564.     30,40,51,45,33,48,
  565.     44,49,39,56,34,53,
  566.     46,42,50,36,29,32,
  567. };
  568.  
  569. /*
  570.  * The C and D arrays used to calculate the key schedule.
  571.  */
  572.  
  573. static    char    C[28];
  574. static    char    D[28];
  575. /*
  576.  * The key schedule.
  577.  * Generated from the key.
  578.  */
  579. static char KS[16][48];
  580.  
  581. /*
  582.  * Set up the key schedule from the key.
  583.  */
  584.  
  585. static void
  586. nbssetkey(key)
  587.     char *key;
  588. {
  589.     register i, j, k;
  590.     int t;
  591.  
  592.     /*
  593.      * First, generate C and D by permuting
  594.      * the key.  The low order bit of each
  595.      * 8-bit char is not used, so C and D are only 28
  596.      * bits apiece.
  597.      */
  598.     for (i=0; i<28; i++) {
  599.         C[i] = key[PC1_C[i]-1];
  600.         D[i] = key[PC1_D[i]-1];
  601.     }
  602.     /*
  603.      * To generate Ki, rotate C and D according
  604.      * to schedule and pick up a permutation
  605.      * using PC2.
  606.      */
  607.     for (i=0; i<16; i++) {
  608.         /*
  609.          * rotate.
  610.          */
  611.         for (k=0; k<shifts[i]; k++) {
  612.             t = C[0];
  613.             for (j=0; j<28-1; j++)
  614.                 C[j] = C[j+1];
  615.             C[27] = t;
  616.             t = D[0];
  617.             for (j=0; j<28-1; j++)
  618.                 D[j] = D[j+1];
  619.             D[27] = t;
  620.         }
  621.         /*
  622.          * get Ki. Note C and D are concatenated.
  623.          */
  624.         for (j=0; j<24; j++) {
  625.             KS[i][j] = C[PC2_C[j]-1];
  626.             KS[i][j+24] = D[PC2_D[j]-28-1];
  627.         }
  628.     }
  629.     return;
  630. }
  631.  
  632.  
  633. /*
  634.  * The 8 selection functions.
  635.  * For some reason, they give a 0-origin
  636.  * index, unlike everything else.
  637.  */
  638. static const char S[8][64] = {
  639.     14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
  640.      0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
  641.      4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
  642.     15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
  643.  
  644.     15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
  645.      3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
  646.      0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
  647.     13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
  648.  
  649.     10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
  650.     13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
  651.     13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
  652.      1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
  653.  
  654.      7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
  655.     13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
  656.     10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
  657.      3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
  658.  
  659.      2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
  660.     14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
  661.      4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
  662.     11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
  663.  
  664.     12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
  665.     10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
  666.      9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
  667.      4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
  668.  
  669.      4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
  670.     13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
  671.      1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
  672.      6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
  673.  
  674.     13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
  675.      1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
  676.      7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
  677.      2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
  678. };
  679.  
  680. /*
  681.  * P is a permutation on the selected combination
  682.  * of the current L and key.
  683.  */
  684. static const char P[] = {
  685.     16, 7,20,21,
  686.     29,12,28,17,
  687.      1,15,23,26,
  688.      5,18,31,10,
  689.      2, 8,24,14,
  690.     32,27, 3, 9,
  691.     19,13,30, 6,
  692.     22,11, 4,25,
  693. };
  694.  
  695. /*
  696.  * The current block, divided into 2 halves.
  697.  */
  698. static char L[32], R[32];
  699. static char tempL[32];
  700. static char f[32];
  701.  
  702. /*
  703.  * The combination of the key and the input, before selection.
  704.  */
  705. static char preS[48];
  706.  
  707. /*
  708.  * The payoff: encrypt a block.
  709.  */
  710.  
  711. static void
  712. blkencrypt(block, edflag)
  713.     char *block;
  714. {
  715.     int i, ii;
  716.     register t, j, k;
  717.  
  718.     /*
  719.      * First, permute the bits in the input
  720.      */
  721.     for (j=0; j<64; j++)
  722.         L[j] = block[IP[j]-1];
  723.     /*
  724.      * Perform an encryption operation 16 times.
  725.      */
  726.     for (ii=0; ii<16; ii++) {
  727.         /*
  728.          * Set direction
  729.          */
  730.         if (edflag)
  731.             i = 15-ii;
  732.         else
  733.             i = ii;
  734.         /*
  735.          * Save the R array,
  736.          * which will be the new L.
  737.          */
  738.         for (j=0; j<32; j++)
  739.             tempL[j] = R[j];
  740.         /*
  741.          * Expand R to 48 bits using the E selector;
  742.          * exclusive-or with the current key bits.
  743.          */
  744.         for (j=0; j<48; j++)
  745.             preS[j] = R[E[j]-1] ^ KS[i][j];
  746.         /*
  747.          * The pre-select bits are now considered
  748.          * in 8 groups of 6 bits each.
  749.          * The 8 selection functions map these
  750.          * 6-bit quantities into 4-bit quantities
  751.          * and the results permuted
  752.          * to make an f(R, K).
  753.          * The indexing into the selection functions
  754.          * is peculiar; it could be simplified by
  755.          * rewriting the tables.
  756.          */
  757.         for (j=0; j<8; j++) {
  758.             t = 6*j;
  759.             k = S[j][(preS[t+0]<<5)+
  760.                 (preS[t+1]<<3)+
  761.                 (preS[t+2]<<2)+
  762.                 (preS[t+3]<<1)+
  763.                 (preS[t+4]<<0)+
  764.                 (preS[t+5]<<4)];
  765.             t = 4*j;
  766.             f[t+0] = (k>>3)&01;
  767.             f[t+1] = (k>>2)&01;
  768.             f[t+2] = (k>>1)&01;
  769.             f[t+3] = (k>>0)&01;
  770.         }
  771.         /*
  772.          * The new R is L ^ f(R, K).
  773.          * The f here has to be permuted first, though.
  774.          */
  775.         for (j=0; j<32; j++)
  776.             R[j] = L[j] ^ f[P[j]-1];
  777.         /*
  778.          * Finally, the new L (the original R)
  779.          * is copied back.
  780.          */
  781.         for (j=0; j<32; j++)
  782.             L[j] = tempL[j];
  783.     }
  784.     /*
  785.      * The output L and R are reversed.
  786.      */
  787.     for (j=0; j<32; j++) {
  788.         t = L[j];
  789.         L[j] = R[j];
  790.         R[j] = t;
  791.     }
  792.     /*
  793.      * The final output
  794.      * gets the inverse permutation of the very original.
  795.      */
  796.     for (j=0; j<64; j++)
  797.         block[j] = L[FP[j]-1];
  798.     return;
  799. }
  800. /*
  801.     getutmp()
  802.     return a pointer to the system utmp structure associated with
  803.     terminal sttyname, e.g. "/dev/tty3"
  804.     Is version independent-- will work on v6 systems
  805.     return NULL if error
  806. */
  807.  
  808. static struct utmp *
  809. getutmp(sttyname)
  810.     char *sttyname;
  811. {
  812.     static struct utmp utmpstr;
  813.     FILE *fdutmp;
  814.  
  815.     if(sttyname == NULL || sttyname[0] == 0)return(NULL);
  816.  
  817.     fdutmp = fopen("/etc/utmp","r");
  818.     if(fdutmp == NULL)return(NULL);
  819.  
  820.     while(fread((char *) &utmpstr, 1, sizeof utmpstr, fdutmp)
  821.         == sizeof utmpstr)
  822.         if(strcmp(utmpstr.ut_line,sttyname+5) == 0){
  823.             fclose(fdutmp);
  824.             return(&utmpstr);
  825.         }
  826.     fclose(fdutmp);
  827.     return(NULL);
  828. }
  829.  
  830. static void
  831. sreverse(sto, sfrom)
  832.     register char *sto, *sfrom;
  833. {
  834.     register int i;
  835.  
  836.     i = strlen(sfrom);
  837.     while (i >= 0)
  838.         *sto++ = sfrom[i--];
  839.     return;
  840. }
  841.  
  842. static char *
  843. mkenvkey(mch)
  844.     char mch;
  845. {
  846.     static char skey[40];
  847.     register struct utmp *putmp;
  848.     char stemp[40], stemp1[40], sttyname[30];
  849.     register char *sk,*p;
  850.  
  851.     if (isatty(2))
  852.         strcpy(sttyname,ttyname(2));
  853.     else if (isatty(0))
  854.         strcpy(sttyname,ttyname(0));
  855.     else if (isatty(1))
  856.         strcpy(sttyname,ttyname(1));
  857.     else
  858.         return (NULL);
  859.     putmp = getutmp(sttyname);
  860.     if (putmp == NULL)
  861.         return (NULL);
  862.     sk = skey;
  863.     p = putmp->ut_line;
  864.     while (*p)
  865.         *sk++ = *p++;
  866.     *sk++ = mch;
  867.     (void)sprintf(stemp, "%ld", putmp->ut_time);
  868.     sreverse(stemp1, stemp);
  869.     p = stemp1;
  870.     while (*p)
  871.         *sk++ = *p++;
  872.     *sk = 0;
  873.     return (skey);
  874. }
  875.  
  876. void
  877. mkpwunclear(spasswd,mch,sencpasswd)
  878.     char mch, *spasswd, *sencpasswd;
  879. {
  880.     register char *skey;
  881.  
  882.     if (spasswd[0] == 0) {
  883.         sencpasswd[0] = 0;
  884.         return;
  885.     }
  886.     skey = mkenvkey(mch);
  887.     if (skey == NULL) {
  888.         fprintf(stderr, "Can't make key\n");
  889.         exit(1);
  890.     }
  891.     (void) nbsencrypt(spasswd, skey, sencpasswd);
  892.     return;
  893. }
  894.  
  895. void
  896. mkpwclear(sencpasswd,mch,spasswd)
  897.     char mch, *spasswd, *sencpasswd;
  898. {
  899.     register char *skey;
  900.  
  901.     if (sencpasswd[0] == 0) {
  902.         spasswd[0] = 0;
  903.         return;
  904.     }
  905.     skey = mkenvkey(mch);
  906.     if (skey == NULL) {
  907.         fprintf(stderr, "Can't make key\n");
  908.         exit(1);
  909.     }
  910.     (void) nbsdecrypt(sencpasswd, skey, spasswd);
  911.     return;
  912. }
  913. @
  914.  
  915.  
  916. 1.7
  917. log
  918. @Lint.
  919. @
  920. text
  921. @d25 19
  922. a43 5
  923. int    renv(), rnetrc(), token(), enblkclr(), enblknot(), nbssetkey();
  924. int    blkencrypt();
  925. char    *renvlook(), *malloc(), *index(), *getenv(), *getpass(), *getlogin();
  926. char    *ttyname();
  927. struct    utmp *getutmp();
  928. d45 1
  929. d47 1
  930. d73 1
  931. d76 1
  932. a76 1
  933. static
  934. d102 1
  935. d105 1
  936. a105 2
  937. static
  938. char *
  939. d158 1
  940. a158 1
  941. static
  942. d229 1
  943. a229 1
  944. static
  945. a268 4
  946. char *deblknot(), *deblkclr();
  947. char *nbs8decrypt(), *nbs8encrypt();
  948. static char    E[48];
  949.  
  950. d282 3
  951. a284 2
  952. static
  953. char *nbsencrypt(str,key,result)
  954. d286 2
  955. a287 1
  956.   char *str, *key; {
  957. d300 4
  958. a303 3
  959.     }
  960. static
  961. char *nbsdecrypt(cpt,key,result)
  962. d305 2
  963. a306 1
  964.   char *cpt,*key; {
  965. d323 4
  966. a326 3
  967. static
  968. char *nbs8encrypt(str,key)
  969. char *str, *key; {
  970. d340 4
  971. a343 3
  972. static
  973. char *nbs8decrypt(crp,key)
  974. char *crp, *key; {
  975. d357 1
  976. a357 1
  977. static
  978. d359 2
  979. a360 1
  980. char *blk,*str; {
  981. d365 3
  982. a367 4
  983.         for(j=0; j<7; j++, i++)
  984.             blk[i] = (c>>(6-j)) & 01;
  985.         i++;
  986.         }
  987. d369 2
  988. d390 1
  989. a390 1
  990. static
  991. d392 3
  992. a394 2
  993. char *blk;
  994. char *crp; {
  995. d397 1
  996. d400 7
  997. a406 7
  998.         if(c>'Z') c -= 6;
  999.         if(c>'9') c -= 7;
  1000.         c -= '.';
  1001.         for(j=0; j<6; j++, i++)
  1002.             blk[i] = (c>>(5-j)) & 01;
  1003.         }
  1004.     }
  1005. d408 4
  1006. a411 3
  1007. static
  1008. char *deblknot(blk)
  1009. char *blk; {
  1010. d415 2
  1011. a416 1
  1012.     for(i=0; i<11; i++){
  1013. d455 1
  1014. a455 1
  1015. static    char    FP[] = {
  1016. d472 1
  1017. a472 1
  1018. static    char    PC1_C[] = {
  1019. d479 1
  1020. a479 1
  1021. static    char    PC1_D[] = {
  1022. d489 1
  1023. a489 1
  1024. static    char    shifts[] = {
  1025. d497 1
  1026. a497 1
  1027. static    char    PC2_C[] = {
  1028. d504 1
  1029. a504 1
  1030. static    char    PC2_D[] = {
  1031. d521 1
  1032. a521 1
  1033. static    char    KS[16][48];
  1034. d527 1
  1035. a527 1
  1036. static
  1037. d529 1
  1038. a529 1
  1039. char *key;
  1040. d571 1
  1041. d580 1
  1042. a580 1
  1043. static    char    S[8][64] = {
  1044. d626 1
  1045. a626 1
  1046. static    char    P[] = {
  1047. d640 3
  1048. a642 3
  1049. static    char    L[32], R[32];
  1050. static    char    tempL[32];
  1051. static    char    f[32];
  1052. d647 1
  1053. a647 1
  1054. static    char    preS[48];
  1055. d653 1
  1056. a653 1
  1057. static
  1058. d655 1
  1059. a655 1
  1060. char *block;
  1061. d740 1
  1062. d749 4
  1063. a752 3
  1064. static
  1065. struct utmp *getutmp(sttyname)
  1066. char *sttyname;
  1067. d772 1
  1068. a772 1
  1069. static
  1070. d781 1
  1071. d784 2
  1072. a785 2
  1073. static
  1074. char *mkenvkey(mch)
  1075. d818 1
  1076. d834 1
  1077. d837 1
  1078. d853 1
  1079. @
  1080.  
  1081.  
  1082. 1.6
  1083. log
  1084. @Lint.
  1085. @
  1086. text
  1087. @d191 2
  1088. a192 1
  1089.                 *apass = malloc((unsigned) strlen(tokval) + 1));
  1090. @
  1091.  
  1092.  
  1093. 1.5
  1094. log
  1095. @Lint.
  1096. @
  1097. text
  1098. @d75 1
  1099. a75 1
  1100.         *aname = malloc(comma - cp + 1);
  1101. d81 1
  1102. a81 1
  1103.     cp = malloc(strlen(comma)+1);
  1104. d175 2
  1105. a176 1
  1106.                     *aname = malloc(strlen(tokval) + 1);
  1107. d191 1
  1108. a191 1
  1109.                 *apass = malloc(strlen(tokval) + 1);
  1110. d733 2
  1111. a734 1
  1112.     while(fread(&utmpstr,1,sizeof utmpstr,fdutmp) == sizeof utmpstr)
  1113. d802 1
  1114. a802 1
  1115.     nbsencrypt(spasswd, skey, sencpasswd);
  1116. d819 1
  1117. a819 1
  1118.     nbsdecrypt(sencpasswd, skey, spasswd);
  1119. @
  1120.  
  1121.  
  1122. 1.4
  1123. log
  1124. @Lint.
  1125. @
  1126. text
  1127. @d64 1
  1128. a64 1
  1129.     char *stemp, fgetlogin, *comma;
  1130. @
  1131.  
  1132.  
  1133. 1.3
  1134. log
  1135. @Lint.
  1136. @
  1137. text
  1138. @d28 1
  1139. @
  1140.  
  1141.  
  1142. 1.2
  1143. log
  1144. @Add forward declarations for integer procedures to keep gcc from complaining.
  1145. @
  1146. text
  1147. @d23 1
  1148. @
  1149.  
  1150.  
  1151. 1.1
  1152. log
  1153. @Initial revision
  1154. @
  1155. text
  1156. @d24 2
  1157. @
  1158.